{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "from math import *\n",
    "import numpy as np\n",
    "import os\n",
    "from IPython.display import HTML\n",
    "from tqdm import tqdm\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/root/.pyenv/versions/3.6.2/lib/python3.6/importlib/_bootstrap.py:205: RuntimeWarning: compiletime version 3.5 of module 'tensorflow.python.framework.fast_tensor_util' does not match runtime version 3.6\n",
      "  return f(*args, **kwds)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../dataset/train-images-idx3-ubyte.gz\n",
      "Extracting ../dataset/train-labels-idx1-ubyte.gz\n",
      "Extracting ../dataset/t10k-images-idx3-ubyte.gz\n",
      "Extracting ../dataset/t10k-labels-idx1-ubyte.gz\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "mnist = input_data.read_data_sets(\"../dataset/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "interval = 0.01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 3x3 memristor crossbar\n",
    "# 전압으로 MEMRISTOR 저\n",
    "class Memristor:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.x = 0.1\n",
    "        self.xp = 0.1\n",
    "        self.xn = 0.2\n",
    "        self.vp = 1.5\n",
    "        self.vn = 0.7\n",
    "        self.alphap = 6\n",
    "        self.alphan = 4\n",
    "        self.a1 = 4e-4\n",
    "        self.a2 = 3e-4\n",
    "        self.ap = 0.032\n",
    "        self.an = 0.001\n",
    "        self.b = 1.0\n",
    "        \n",
    "        self.gf = 0.0\n",
    "        \n",
    "        self.interval = interval\n",
    "        self.conductance = 0\n",
    "        self.resistance = 0\n",
    "    \n",
    "    def change_x(self, V):\n",
    "        if V >= 0:\n",
    "            if self.x >= self.xp:\n",
    "                self.f = exp(-self.alphap*(self.x - self.xp)) * (((self.xp - self.x)/(1 - self.xp)) + 1)\n",
    "            else:\n",
    "                self.f = 1.0\n",
    "        elif V < 0:\n",
    "            if self.x <= (1 - self.xn):\n",
    "                self.f = exp(self.alphan*(self.x + self.xn - 1.0)) * (self.x/(1-self.xn))\n",
    "            else:\n",
    "                self.f = 1.0\n",
    "            \n",
    "        if V > self.vp:\n",
    "            self.g = self.ap * (exp(V)-exp(self.vp))\n",
    "        elif V < -self.vn:\n",
    "            self.g = -self.an * (exp(-V)-exp(self.vn))\n",
    "        else:\n",
    "            self.g = 0\n",
    "            \n",
    "        self.gf = self.f * self.g\n",
    "        self.x += self.gf * self.interval\n",
    "    \n",
    "    def activate(self, V):\n",
    "        self.change_x(V)\n",
    "        \n",
    "        if V >= 0:\n",
    "            curr = self.a1 * self.x * sinh(self.b * V)\n",
    "        else:\n",
    "            curr = self.a2 * self.x * sinh(self.b * V)\n",
    "        \n",
    "        try: self.resistance = V / curr\n",
    "        except ZeroDivisionError as e:\n",
    "            print(e)\n",
    "            \n",
    "        try: self.conductance = 1 / self.resistance\n",
    "        except ZeroDivisionError as e:\n",
    "            print(e)\n",
    "            \n",
    "        return curr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class DataBalancing:\n",
    "    def __init__(self):\n",
    "        self.quantity = 60000\n",
    "        self.balance_num = 2000\n",
    "    \n",
    "    def activate(self):\n",
    "        self.images = mnist.train.images[:self.quantity]\n",
    "        self.labels = mnist.train.labels[:self.quantity]\n",
    "        self.data_dict = {}\n",
    "        for i in range(10):\n",
    "            self.data_dict[i] = []\n",
    "        for ii,num in enumerate(self.labels):\n",
    "            self.data_dict[num].append(self.images[ii])\n",
    "        \n",
    "        for i in range(10):\n",
    "            self.data_dict[i][:self.balance_num]\n",
    "            \n",
    "        self.output_list = []\n",
    "        self.label_list = []\n",
    "        for times in tqdm(range(self.balance_num)):\n",
    "            for ii in range(10):\n",
    "                self.output_list.append(self.data_dict[ii][times])\n",
    "                self.label_list.append(ii)\n",
    "                \n",
    "        return self.output_list, self.label_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████████| 2000/2000 [00:00<00:00, 268469.82it/s]\n"
     ]
    }
   ],
   "source": [
    "databalance = DataBalancing()\n",
    "balanced_image_list, balanced_label_list = databalance.activate()\n",
    "del databalance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# reverse imaging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class AfterReverseImaging:\n",
    "    def __init__(self, images, labels, quantity=4000):\n",
    "        self.quantity = quantity\n",
    "        self.images = images\n",
    "        self.labels = labels\n",
    "        self.size = 22\n",
    "        self.row_num = self.size**2\n",
    "        self.column_num = 10\n",
    "        self.loss_list=[]\n",
    "        self.accuracy_list=[]\n",
    "        \n",
    "    def make_mem_crossbar(self, cross_id):\n",
    "        # Build Memristor crossbar\n",
    "        for i in range(self.row_num):\n",
    "            for j in range(self.column_num):\n",
    "                exec('self.mem_%c_%d_%d = Memristor(\"mem_%c_%d_%d\")'%(cross_id,i,j,cross_id,i,j))\n",
    "        \n",
    "    def crossbar_matrix(self):\n",
    "        self.mem_matrix = {'o':[],'r':[]}\n",
    "        for row in range(self.row_num):\n",
    "            row_list = []\n",
    "            for column in range(self.column_num):\n",
    "                exec('row_list.append(self.mem_%c_%d_%d.conductance)'%('o',row,column))\n",
    "            self.mem_matrix['o'].append(row_list)\n",
    "            \n",
    "        for row in range(self.row_num):\n",
    "            row_list = []\n",
    "            for column in range(self.column_num):\n",
    "                exec('row_list.append(self.mem_%c_%d_%d.conductance)'%('r',row,column))\n",
    "            self.mem_matrix['r'].append(row_list)\n",
    "    \n",
    "    def data_size_reduction(self):\n",
    "        #os.mkdir(\"../dataset/size_reduced_image_path\")\n",
    "        #os.chdir(\"../dataset/size_reduced_image_path\")\n",
    "        \n",
    "        input_images = self.images[:self.quantity]\n",
    "        labels = self.labels[:self.quantity]\n",
    "        size_reducted_images = []\n",
    "        for im in input_images:\n",
    "            pil_im = Image.fromarray(np.reshape(im, [28,28]))\n",
    "            size_reducted_images.append(np.reshape(np.array(pil_im.resize([self.size, self.size])), [1, self.row_num])[0])\n",
    "        return size_reducted_images, labels\n",
    "    \n",
    "    def reverse(self, image):\n",
    "        return 1.0 - np.array(image)\n",
    "    \n",
    "    def split_train_test(self, images, labels, train_ratio=0.90):\n",
    "        # img path 를 받아서 train, test set을 list로 추출해서 나눠줌 --> path는 좀 더 데이터 사이즈가 커졌을 때 사용해도 될 듯\n",
    "        train_quantity = int(len(images)*train_ratio)\n",
    "        train_image_list = images[:train_quantity]\n",
    "        train_label_list = labels[:train_quantity]\n",
    "        test_image_list = images[train_quantity:]\n",
    "        test_label_list = labels[train_quantity:]\n",
    "        return train_image_list, train_label_list, test_image_list, test_label_list\n",
    "    \n",
    "    def after_imaging(self, train_image, train_label, insert_time=0.6):\n",
    "        # ms 단위의 이미지 sending (그 때 써놓았던 방식대로 작동될 수 있도록 하기)\n",
    "        # image의 검은 부분은 -V 로 들어갈 수 있도록 만들기\n",
    "        # generator 을 사용해서 하나씩 넣는 method 를 만들어도 괜찮을것같다. \n",
    "        voltage_inputs = np.array(train_image)+1.0\n",
    "        for i, V in enumerate(voltage_inputs):\n",
    "            for time in np.arange(0,insert_time,interval):\n",
    "                exec('self.mem_%c_%d_%d.activate(V)'%('o',i,train_label))\n",
    "\n",
    "        rev_voltage_inputs = self.reverse(train_image)+1.0\n",
    "        for ii, VV in enumerate(rev_voltage_inputs):\n",
    "            for non_label in [i for i in range(10) if i != train_label]:\n",
    "                for time in np.arange(0,insert_time,interval):\n",
    "                    exec('self.mem_%c_%d_%d.activate(VV)'%('r',ii,non_label))\n",
    "        \n",
    "    def mem_output(self, cross_id, image_array):\n",
    "        # 현재 멤리스터 상태에서 input 넣고 테스트하기\n",
    "        crossbar_output = np.dot(image_array, self.mem_matrix[cross_id])\n",
    "        return crossbar_output\n",
    "    \n",
    "    def total_output(self, image_array):\n",
    "        minus_rate = 0.8\n",
    "        return self.mem_output('o',image_array) - minus_rate*self.mem_output('r', self.reverse(image_array))\n",
    "    \n",
    "    def winner_take_all(self, crossbar_output):\n",
    "        a = np.argmax(crossbar_output)\n",
    "        output = np.zeros([10])\n",
    "        output[a] = 1\n",
    "        return output\n",
    "    \n",
    "    def loss_function(self):\n",
    "        total_loss = 0.0\n",
    "        for k, label in enumerate(self.train_label_list):\n",
    "            label_onehot = np.zeros([1,10])\n",
    "            label_onehot[0][label] = 1.0\n",
    "            label_onehot = np.array(label_onehot[0])\n",
    "            output = self.total_output(self.train_image_list[k])\n",
    "            #Softmax used to check the loss function\n",
    "            output = np.exp(output*10000)\n",
    "            output /= np.sum(output)\n",
    "            loss_array = label_onehot - output #--> softmax는 값이 너무 작아서 구현이 안되는 듯\n",
    "            #loss_array = label_onehot - output/np.sum(output) # --> just normalized by dividing into sum\n",
    "            loss = np.dot(loss_array, loss_array)\n",
    "            total_loss += loss\n",
    "        return total_loss*10/len(self.train_image_list)\n",
    "    \n",
    "    def train_data_gen(self):\n",
    "        for image, label in list(zip(self.train_image_list, self.train_label_list)):\n",
    "            yield image, label\n",
    "    \n",
    "    def crossbar_animation(self, train_data):\n",
    "    # input 은 없으며 그저 crossbar resistance를 plotting 해줌.\n",
    "    # 그 plotting을 에니메이션적으로 할 수 있으면 좋겠다. \n",
    "    # 그 기준축을 평균으로 잡고, scale도 분산을 계산해서 plotting 되는 것 같은데 그렇게 되지 않도록 하기\n",
    "        self.after_imaging(train_data[0], train_data[1], insert_time=0.6)\n",
    "        self.crossbar_matrix()\n",
    "        #self.loss_list.append(self.loss_function())\n",
    "        #self.accuracy_list.append(self.accuracy())\n",
    "        self.ax1.clear()\n",
    "        self.ax1.matshow(np.transpose(self.mem_matrix['o']), cmap=plt.cm.binary, vmin=0, vmax=5.0e-4)\n",
    "        self.ax1.set_ylabel('Memristor column')\n",
    "        self.ax1.set_xlabel('Memristor row')\n",
    "        \n",
    "#         self.ax2.clear()\n",
    "#         self.ax2.set_xlim([0,100])\n",
    "#         self.ax2.grid()\n",
    "#         self.ax2.set_ylim([0,25])\n",
    "#         self.ax2.set_ylabel('Loss')\n",
    "#         self.ax2.set_xlabel('Number of Times')\n",
    "#         self.ax2.plot(self.loss_list)\n",
    "        \n",
    "#         self.ax3.clear()\n",
    "#         self.ax3.plot(self.accuracy_list)\n",
    "#         self.ax3.set_xlim([0,100])\n",
    "#         self.ax3.grid()\n",
    "#         self.ax3.set_ylim([0,100])\n",
    "#         self.ax3.set_ylabel('Accuracy(%)')\n",
    "#         self.ax3.set_xlabel('Number of Times')\n",
    "        \n",
    "        self.ax4.clear()\n",
    "        self.ax4.matshow(np.transpose(self.mem_matrix['r']), cmap=plt.cm.binary, vmin=0, vmax=5.0e-4)\n",
    "        self.ax4.set_ylabel('Memristor column')\n",
    "        self.ax4.set_xlabel('Memristor row')\n",
    "    \n",
    "    def accuracy(self):\n",
    "        correct_number = 0\n",
    "        for i, input_image in enumerate(self.test_image_list):\n",
    "            if np.argmax(self.total_output(input_image)) == self.test_label_list[i]:\n",
    "                correct_number += 1\n",
    "        return round(correct_number*100/len(self.test_image_list), 2)\n",
    "        \n",
    "    def activate(self):\n",
    "        fig = plt.figure(figsize=(16,9))\n",
    "        self.ax1 = fig.add_subplot(2,1,1)\n",
    "#         self.ax2 = fig.add_subplot(4,1,3)\n",
    "#         self.ax3 = fig.add_subplot(4,1,4)\n",
    "        self.ax4 = fig.add_subplot(2,1,2)\n",
    "        \n",
    "        print(\"Building two Memristor {}x{} crossbar...\".format(self.row_num, self.column_num))\n",
    "        self.make_mem_crossbar('o')\n",
    "        self.make_mem_crossbar('r')\n",
    "        self.crossbar_matrix()\n",
    "        \n",
    "        size_reducted_images, labels = self.data_size_reduction()\n",
    "        self.train_image_list, self.train_label_list, self.test_image_list, self.test_label_list = self.split_train_test(size_reducted_images, labels)\n",
    "        \n",
    "        print('\\nMaking animation...')\n",
    "        self.anim = animation.FuncAnimation(fig, self.crossbar_animation, self.train_data_gen, interval=300, repeat=False)\n",
    "        print('\\nAll process done.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Building two Memristor 484x10 crossbar...\n",
      "\n",
      "Making animation...\n",
      "\n",
      "All process done.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fcc22dbabe0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_2 = AfterReverseImaging(balanced_image_list, balanced_label_list, quantity=20000)\n",
    "train_2.activate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_2.accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Writer = animation.writers['ffmpeg']\n",
    "writer = Writer(fps=5, metadata=dict(artist='Me'), bitrate=1800)\n",
    "\n",
    "train_2.anim.save('../animation/mem_matrix_animation(reverseHD_9(transposed graph only) SADP).mp4', writer=writer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# make figures for presentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# plt.figure(figsize=(20,10))\n",
    "# for i in range(1,11):\n",
    "#     exec(\"ax_%d = plt.subplot(2,5,%d)\"%(i,i))\n",
    "\n",
    "# for i, a in enumerate(databalance.data_dict[9][:10]):\n",
    "#     a = np.reshape(a, [28,28])\n",
    "#     im_a = Image.fromarray(a)\n",
    "#     im_input = np.reshape(np.array(im_a.resize([22, 22])),[1,484])\n",
    "#     exec(\"ax_%d.imshow(a, cmap='gray')\"%(i+1))\n",
    "#     exec(\"ax_%d.set_title('predicted_value = %d')\"%(i+1,np.argmax(train_2.total_output(im_input))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fcc242e5e10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,10))\n",
    "for i in range(1,11):\n",
    "    exec(\"ax_%d = plt.subplot(2,5,%d)\"%(i,i))\n",
    "\n",
    "for i in range(10):\n",
    "    mem_list = np.transpose(train_2.mem_matrix['r'])[i]\n",
    "    a = np.reshape(mem_list, [train_2.size,train_2.size])\n",
    "    exec(\"ax_%d.imshow(a, cmap='gray')\"%(i+1))\n",
    "    exec(\"ax_%d.set_title('memristor column of number %d')\"%(i+1,i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fcc22d4b780>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,10))\n",
    "for i in range(1,11):\n",
    "    exec(\"ax_%d = plt.subplot(2,5,%d)\"%(i,i))\n",
    "\n",
    "for i in range(10):\n",
    "    mem_list = np.transpose(train_2.mem_matrix['o'])[i]\n",
    "    a = np.reshape(mem_list, [train_2.size,train_2.size])\n",
    "    exec(\"ax_%d.imshow(a, cmap='gray')\"%(i+1))\n",
    "    exec(\"ax_%d.set_title('memristor column of number %d')\"%(i+1,i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### white space experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "white_space = np.zeros([1,28*28])\n",
    "white_space += 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pil_im_1 = Image.fromarray(np.reshape(white_space, [28,28]))\n",
    "input_array_1 = np.reshape(np.array(pil_im_1.resize([22, 22])), [1, 22**2])[0]\n",
    "plt.plot(train_2.total_output(input_array_1))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(20,10))\n",
    "plt.plot(train_2.accuracy_list)\n",
    "plt.xlim([0,100])\n",
    "plt.grid()\n",
    "plt.ylim([0,100])\n",
    "plt.ylabel('Accuracy(%)')\n",
    "plt.xlabel('Number of Times')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(20,10))\n",
    "plt.xlim([0,100])\n",
    "plt.grid()\n",
    "plt.ylim([0,25])\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Number of Times')\n",
    "plt.plot(train_2.loss_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
